package com.sf.shiva.oms.common.util;

import java.util.List;
import java.util.regex.Pattern;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 运单处理相关的工具类，该类适合存放与业务无关纯工具的函数，
 * 不能在该类中引用客户端，服务端，扫描端，EXP端，task部分的类
 * 只能在客户端，服务端，扫描端，EXP端，task中调用该类的方法
 * @author 664525
 */
public class StringUtil{
    private StringUtil(){}

    private static final Logger logger=LoggerFactory.getLogger(StringUtil.class);
    /**
     * 判断运单号是否有相应的前缀
     * @author 664525
     * @param inputString 需要判断的字段
     * @param fixs前缀数组
     * @return 如果有则返回true，如果没有返回false
     */
    /**字符串从0的位置开始截取**/
    public static final int STARTINDEX = 0;
    //NULL标识
    public static final String STRING_NULL_FLG = "0"; 
    //自寄标识 add by 664525 PVS 改造
    public static final Integer INT_NULL_FLG = 0; 
    public static boolean isFixString(String inputString,List<String> fixs){        
        
        if(BlankUtil.isBlank(fixs)){
            return false;
        }
        for(String fix:fixs){            
            if(inputString.startsWith(fix)){
                return true;
            }            
        }        
        return false;        
    }
    /**
     * 判断运单号是否有相应的前缀
     * @author 664525
     * @param inputString 需要判断的字段
     * @param fixs前缀数组
     * @return 如果有则返回true，如果没有返回false
     */
    public static boolean isFixString(String inputString,String[] fixs){        
        
        if(BlankUtil.isBlank(fixs)){
            return false;
        }
        for(String fix:fixs){            
            if(inputString.startsWith(fix)){
                return true;
            }            
        }        
        return false;        
    }
    /**
     * 判断输入的字符串是否包含数组中的字段
     * @author 664525
     * @param inputString 需要判断的字段
     * @param fixs后缀数组
     * @return 如果有则返回true，如果没有返回false
     */
    public static boolean isContainsString(String inputString,String[] fixs){        
        
        if(BlankUtil.isBlank(fixs)||BlankUtil.isBlank(inputString)){
            return false;
        }
        for(String fix:fixs){            
            if(inputString.contains(fix)){
                return true;
            }            
        }        
        return false;        
    }
    
    /**
     * 数组中的字符串是否包含输入的字符串
     * @author 664525
     * @param inputString 需要判断的字段
     * @param strList后缀数组
     * @return 如果有则返回true，如果没有返回false
     */
    public static boolean isIncludeString(String inputString,String[] strList){        
        
        if(BlankUtil.isBlank(strList)||BlankUtil.isBlank(inputString)){
            return false;
        }
        for(String str:strList){            
            if(inputString.equals(str)){
                //如果相同的字符串则返回
                return true;
            }            
        }        
        return false;        
    }
    /**
     * 判断字符串数组是否包含另外一个数组中的一个字符串
     * @author 664525
     * @param inputs 需要判断的字段
     * @param fixs后缀数组
     * @return 如果有则返回true，如果没有返回false
     */
    public static boolean isArrayContainsString(List<String> inputs,String[] fixs){
        
        boolean isfixed = false;
        if(BlankUtil.isBlank(fixs)||BlankUtil.isBlank(inputs)){
            return false;
        }
        for(String input:inputs){
            if(StringUtil.isContainsString(input,fixs)){
                isfixed = true;
                break;
            }
        }          
        return isfixed;        
    }
    /**
     * @author 664525
     * 将输入的字符串保留前面num位后面的变成convert
     * @param input
     * @param convert
     * @param num
     * @return
     */
    public static String cutShortStr(String input,int num){
        
        if(!BlankUtil.isBlank(input)&&input.length()>num){            
            
            return input.substring(STARTINDEX,num);                        
        }else{            
            return input;
        }
    }
    
    /**
     * 判断是否是为空或空的字符
     * @param str
     * @return
     * @author 670513
     */
    public static boolean isNilString(String str){
        return str == null || str.trim().length() == 0;
    }
    
    /**
     * 判断字符是否非空
     * @param str
     * @return
     * @author 670513
     */
    public static boolean isNotNilString(String str){
        return !isNilString(str);
    }
    
    /**
     * @Title 判断两个字符串是否相等（空格与null也会相等）
     * @Description 判断两个字符串是否相等（空格与null也会相等）
     * @Param str1：字符串1
     * @Param str2：字符串2
     * @return boolean：true：相等。false：不相等
     * @author 80002089
     * @Date 2016年8月1日
     */
    public static boolean equalsString(String str1 ,String str2){
        if(isNilString(str1)){
            str1 = "";
        }
        if(isNilString(str2)){
            str2 = "";
        }
        return StringUtils.equals(str1, str2);
    }
    
    /**
     * 
     * @param value1
     * @param value2
     * @return
     */
    public static String removeLast(String value1,String value2) {

        try{
            if(BlankUtil.isBlank(value1)||BlankUtil.isBlank(value2)){
                
                return value1;
            }
            while(value1.endsWith(value2)){
                value1 = value1.substring(0, value1.length() - value2.length());            
            }
        }catch(Exception e){
            logger.error(ExceptionUtils.extractStackTrace(e));
            return value1;
        }
        return value1;
    }
    
    
    /**
     * 是否纯数字的字符串
     * 如果空返回假
     * @param str
     * @return
     */
    public static boolean isDigitalString(String str){
        if (isNilString(str)){
            return false;
        }
        return Pattern.compile("^\\d+$").matcher(str).matches();
    }
    

    /**
     * 把null的字符串转为空字符串以免报异常
     * @param str1
     * @return
     */
    public static String nullToBlank(String str1){
        
        if(str1 == null){
            return "";
        }else{
            return str1;
        }        
    }
    /**
     * 返回字符串前缀
     * @param str
     * @return
     */
    public static String stringPreFix(String str){
        
        try{
            char[] chars = str.toCharArray();
            int i = chars.length-1;
            for(;i>=0;i--){
                if(chars[i]>='A' && chars[i]<='Z'){
                    break;
                }
            }
            if(i==-1){
                i=0;
            }
            return     str.substring(0,i+1);
        }catch(Exception e){
            logger.error(ExceptionUtils.extractStackTrace(e));
            return null;
        }
                
    }
    /**
     * 返回数字后缀
     * @param str
     * @return
     */
    public static Long numEndFix(String str){
        
        try{
            char[] chars = str.toCharArray();
            int i = chars.length-1;
            for(;i>=0;i--){
                if(chars[i]>='A'&& chars[i]<='Z'){
                    break;
                }
            }
            if(i==-1){
                i=0;
            }
            return     NumberUtil.string2Long(str.substring(i+1));    
        }catch(Exception e){
            logger.error(ExceptionUtils.extractStackTrace(e));
            return null;
        }
            
    }
    
    /**
     * 字符串是否不为空,除了原有的空之外，还加上null/NULL/Null的判断
     * @param str
     * @return
     * @author 80002088
     * 2018年4月4日
     */
    public static boolean isStrNotNull(String str){
    	return !(StringUtils.isBlank(str)||"null".equals(str)||"NULL".equals(str)||"Null".equals(str));
    }
    
    /**
     * 截取字符串，取最后一个位
     * 
     * @param str
     * @param splitStr
     * @return
     * @author LA.01367604-2018年4月23日
     */
    public static String getLastName(String str, String splitStr) {
        if (str.indexOf(splitStr) < 0) {
            return str;
        } else {
            return str.substring(str.lastIndexOf(splitStr) + 1, str.length());
        }
    }

}
